package com.kun.rental.service.impl;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.kun.rental.entity.User;
import com.kun.rental.entity.UserRole;
import com.kun.rental.mapper.UserMapper;
import com.kun.rental.mapper.UserRoleMapper;
import com.kun.rental.service.IOssService;
import com.kun.rental.service.IRoleService;
import com.kun.rental.service.IUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.kun.rental.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.Arrays;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author ikun
 * @since 2024-07-04
 */
@Service
@Transactional
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private IOssService ossService;

    @Autowired
    private UserRoleMapper userRoleMapper;

    @Autowired
    private IRoleService roleService;


    /**
     * 根据用户名查询用户信息。
     *
     * @param username 用户名，作为查询条件。
     * @return 查询到的用户对象，如果不存在则返回null。
     */
    @Override
    public User selectByUsername(String username) {
        // 创建查询条件对象，并设置用户名等于传入的参数username
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", username);

        // 使用BaseMapper的selectOne方法，根据查询条件查询用户信息
        // 如果存在匹配的用户，则返回该用户对象；否则返回null
        return baseMapper.selectOne(queryWrapper);
    }

    /**
     * 根据用户ID选择角色名称。
     *
     * @param id 用户ID，作为查询角色名称的依据。
     * @return 返回一个包含角色名称的字符串列表。如果用户没有角色或查询失败，返回空列表。
     */
    @Override
    public List<String> selectRoleName(int id) {
        return baseMapper.selectRoleNameByUserId(id);
    }


    @Override
    public Page<User> searchByPage(Page<User> page, User user) {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        if (user.getDeptId() != null && user.getDeptId() == 0) {
            return userMapper.selectPage(page, null);
        }
        wrapper.eq(ObjectUtil.isNotEmpty(user.getDeptId()), "dept_id", user.getDeptId());   // 部门id查询
        wrapper.like(StrUtil.isNotEmpty(user.getUsername()), "username", user.getUsername());    //用户名查询
        wrapper.like(StrUtil.isNotEmpty(user.getRealname()), "realname", user.getRealname());   //真实姓名查询
        wrapper.like(StrUtil.isNotEmpty(user.getNickname()), "nickname", user.getNickname());   //昵称查询
        wrapper.like(StrUtil.isNotEmpty(user.getPhone()), "phone", user.getPhone());    //手机号查询
        wrapper.like(StrUtil.isNotEmpty(user.getEmail()), "email", user.getEmail());    //邮箱查询
        return userMapper.selectPage(page, wrapper);
    }

    /**
     * 删除用户
     * @param ids
     * @return
     */
    @Override
    public boolean delete(String ids) {
        List<Integer> list = Arrays.stream(ids.split(","))
                .map(Integer::parseInt).toList();
        try {
            if (!list.isEmpty()) {
                list.forEach(id -> {
                    User user = baseMapper.selectById(id);
                    if (user.getIsAdmin() != null && user.getIsAdmin() != 1) {
                        //删除时，要同时删除用户的头像
                        if (user.getAvatar()!=null){
                            ossService.delete(user.getAvatar());
                        }
                        //删除用户
                        baseMapper.deleteById(id);
                        //删除用户和角色关联表数据
                        userRoleMapper.delete(
                                new QueryWrapper<UserRole>().eq("user_id", id));
                    }
                });
            }
            return true;

        } catch (Exception e) {
            throw new RuntimeException("删除失败");
        }
    }



    //获取当前用户所绑定的角色id
    @GetMapping("role/{userId}")
    public Result selectRoleByUserId(@PathVariable Integer userId){
        return Result.success(roleService.selectRoleIdByUserId(userId));
    }


    /**
     * 绑定角色
     * @param userId
     * @param list
     * @return
     */
    @Override
    public boolean bindRole(Integer userId, List<Integer> list) {
        //先删除所有当前用户和角色的关联
        userRoleMapper.delete(
                new QueryWrapper<UserRole>().eq("user_id", userId));
        //重新插入用户和角色关联
        if (!list.isEmpty()){
            list.forEach(roleId -> {
                UserRole userRole = new UserRole();
                userRole.setUserId(userId);
                userRole.setRoleId(roleId);
                userRoleMapper.insert(userRole);
            });
            return true;
        }
        return false;
    }

}
